import axios from 'axios';

/**
 * API服务模块
 * 
 * 本模块提供了完整的API接口封装，包括：
 * 1. 新版v1 API - 标准化的RESTful接口
 * 2. 兼容旧版API - 保持向后兼容性
 * 3. 统一的错误处理和响应格式
 * 4. 请求拦截器和响应拦截器
 * 5. 用户认证和登录功能
 * 
 * 使用示例：
 * import apiService from '@/services/api';
 * 
 * // 获取分类列表
 * const categories = await apiService.categories.getList();
 * 
 * // 获取内容详情
 * const content = await apiService.content.getDetail('path/to/content');
 * 
 * @author Frontend Team
 * @version 2.0.0
 */

// 手动切换开关 - 修改这里来切换环境
const USE_LOCAL_SERVER = true; // 改为 true 使用本地服务器，false 使用相对路径

// 根据开关决定baseURL
const getBaseURL = () => {
  if (USE_LOCAL_SERVER) {
    return 'http://localhost:8080/api/v1';
  }
  return '/api/v1'; // 使用相对路径，利用nginx代理
};

// 创建axios实例
const api = axios.create({
  baseURL: getBaseURL(),
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 请求拦截器
api.interceptors.request.use(
  config => {
    // 添加token到请求头
    const token = localStorage.getItem('token');
    console.log('🔍 API拦截器 - 当前token:', token);
    console.log('🔍 API拦截器 - 请求URL:', config.url);
    console.log('🔍 API拦截器 - 请求方法:', config.method?.toUpperCase());
    if (token) {
      config.headers['Authorization'] = `Bearer ${token}`;
      console.log('✅ API拦截器 - Authorization头已添加');
    } else {
      console.log('⚠️ API拦截器 - 没有找到token');
    }
    return config;
  },
  error => {
    return Promise.reject(error);
  }
);

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 处理响应数据
    const res = response.data;
    console.log('✅ API拦截器 - 响应成功:', {
      url: response.config?.url,
      method: response.config?.method?.toUpperCase(),
      status: response.status,
      code: res.code
    });
    if (res.code !== 200) {
      console.error('❌ API错误:', res.message);
      return Promise.reject(new Error(res.message || res.error || '未知错误'));
    }
    // 返回完整的响应对象，保持data结构
    return res;
  },
  error => {
    console.error('❌ 请求错误详情:', {
      url: error.config?.url,
      method: error.config?.method?.toUpperCase(),
      status: error.response?.status,
      statusText: error.response?.statusText,
      data: error.response?.data,
      message: error.message
    });
    
    // 处理401未授权错误
    if (error.response && error.response.status === 401) {
      console.warn('⚠️ Token已过期或无效，清除认证信息');
      console.log('🔍 当前localStorage token:', localStorage.getItem('token'));
      // 清除本地存储的认证信息
      localStorage.removeItem('token');
      localStorage.removeItem('userInfo');
      // 清除axios默认请求头中的token
      delete api.defaults.headers.common['Authorization'];
      // 刷新页面回到登录状态
      window.location.reload();
    }
    
    return Promise.reject(error);
  }
);

// API方法
const apiService = {
  // === 新版 v1 API ===
  
  // 1. 分类管理API
  categories: {
    // 获取分类列表
    getList: (params = {}) => api.get('/categories', { params }),
    
    // 获取分类详情
    getDetail: (id) => api.get(`/categories/${id}`),
    
    // 获取分类及其项目
    getWithItems: (id) => api.get(`/categories/${id}/items`),
    
    // 管理端API
    create: (category) => api.post('/admin/categories', category),
    update: (id, category) => api.put(`/admin/categories/${id}`, category),
    delete: (id) => api.delete(`/admin/categories/${id}`),
    getHierarchy: () => api.get('/admin/categories/hierarchy')
  },

  // 2. 项目管理API
  items: {
    // 获取项目列表
    getList: (params = {}) => api.get('/items', { params }),
    
    // 获取项目详情
    getDetail: (id) => api.get(`/items/${id}`),
    
    // 获取项目及其分类信息
    getWithCategory: (id) => api.get(`/items/${id}/category`),
    
    // 管理端API
    create: (item) => api.post('/admin/items', item),
    
    /**
     * 创建项目（支持文件上传）
     * @param {FormData} formData - 包含文件的表单数据
     * @returns {Promise} API响应
     */
    createWithFile: (formData) => {
      return api.post('/admin/items', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
    },
    
    update: (id, item) => api.put(`/admin/items/${id}`, item),
    
    /**
     * 更新项目（支持文件上传）
     * @param {string|number} id - 项目ID
     * @param {FormData} formData - 包含文件的表单数据
     * @returns {Promise} API响应
     */
    updateWithFile: (id, formData) => {
      return api.put(`/admin/items/${id}`, formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
    },
    
    delete: (id) => api.delete(`/admin/items/${id}`),
    
    // 富文本相关API
    /**
     * 获取富文本项目列表
     * @param {Object} params - 查询参数
     * @returns {Promise} API响应
     */
    getRichTextList: (params = {}) => api.get('/items', { 
      params: { ...params, content_type: 'rich_text' } 
    }),
    
    /**
     * 校验项目内容类型
     * @param {string|number} id - 项目ID
     * @returns {Promise} API响应
     */
    validateContentType: (id) => api.get(`/items/${id}/validate-content-type`),
    
    /**
     * 创建富文本项目
     * @param {Object} item - 项目数据
     * @returns {Promise} API响应
     */
    createRichText: (item) => {
      return api.post('/admin/items', {
        ...item,
        content_type: 'rich_text'
      });
    },
    
    /**
     * 更新富文本项目
     * @param {string|number} id - 项目ID
     * @param {Object} item - 项目数据
     * @returns {Promise} API响应
     */
    updateRichText: (id, item) => {
      return api.put(`/admin/items/${id}`, {
        ...item,
        content_type: 'rich_text'
      });
    },
    
    /**
     * 上传图片文件（专用于富文本编辑器）
     * @param {FormData} formData - 包含图片文件的表单数据
     * @returns {Promise} API响应
     */
    uploadImage: (formData) => {
      return api.post('/admin/upload/image', formData, {
        headers: {
          'Content-Type': 'multipart/form-data'
        }
      });
    }
  },

  // 3. 页面数据API
  pages: {
    // 获取页面完整数据（兼容旧版本）
    getData: (pageName) => api.get(`/page/${pageName}`),
    
    // 获取页面列表
    getList: () => api.get('/pages'),
    
    // 根据代码获取页面详情
    getByCode: (code) => api.get(`/pages/code/${code}`),
    
    // 获取页面及其分类
    getWithCategories: (code) => api.get(`/pages/${code}/categories`),
    
    // 管理端API
    create: (page) => api.post('/admin/pages', page),
    update: (id, page) => {
      console.log('🔍 apiService - pages.update 调用:', { id, page })
      console.log('📊 apiService - 发送到后端的数据:', JSON.stringify(page, null, 2))
      const request = api.put(`/admin/pages/${id}`, page)
      request.then(result => {
        console.log('✅ apiService - pages.update HTTP 响应:', result)
      }).catch(error => {
        console.error('❌ apiService - pages.update HTTP 错误:', error)
      })
      return request
    },
    delete: (id) => api.delete(`/admin/pages/${id}`),
    getDetail: (id) => api.get(`/admin/pages/${id}`)
  },

  // === 兼容旧版API ===
  
  // 学校介绍相关
  about: {
    getOverview: () => api.get('/about/overview'),
    getSchool: () => api.get('/about/school'),
    getAid: () => api.get('/about/aid'),
    getUs: () => api.get('/about/us')
  },

  // 学院介绍相关
  colleges: {
    getEngineering: () => api.get('/colleges/engineering'),
    getScience: () => api.get('/colleges/science'),
    getLiterature: () => api.get('/colleges/literature'),
    getManagement: () => api.get('/colleges/management'),
    getLanguage: () => api.get('/colleges/language'),
    getArt: () => api.get('/colleges/art'),
    getPreschool: () => api.get('/colleges/preschool')
  },

  // 新生指南相关
  freshman: {
    getCommute: () => api.get('/freshman/commute'),
    getItems: () => api.get('/freshman/items'),
    getPreparation: () => api.get('/freshman/preparation')
  },

  // 校园生活相关
  life: {
    getDorm: () => api.get('/life/dorm'),
    getCanteen: () => api.get('/life/canteen'),
    getInternet: () => api.get('/life/internet'),
    getMarket: () => api.get('/life/market')
  },

  // 学习相关
  study: {
    getLibrary: () => api.get('/study/library'),
    getEnglish: () => api.get('/study/english')
  },

  // 其他功能
  calendar: {
    getInfo: () => api.get('/calendar/info')
  },

  // 4. 内容管理API
  content: {
    // 获取内容列表 - 新版本使用路径参数
    getList: (categoryId, params = {}) => {
      if (categoryId) {
        return api.get(`/content/list/${categoryId}`, { params });
      }
      // 兼容旧版本，如果没有categoryId则使用查询参数
      return api.get('/content/list', { params });
    },

    // 获取内容详情
    getDetail: (contentId) => api.get(`/content/${contentId}`),

    // 更新内容
    update: (id, content) => api.put('/content', {
      id,
      content
    }),

    // 删除内容
    delete: (category, filename) => 
      api.delete('/content/delete', {
        data: { category, filename }
      }),

    // 上传内容
    upload: (filename, content, categoryId = null) => {
      const data = { filename, content };
      if (categoryId) {
        data.categoryId = categoryId;
      }
      return api.post('/content/upload', data);
    },

    // 创建新文档（使用upload接口）
    create: (filename, content = '', categoryId = null) => {
      const data = { filename, content };
      if (categoryId) {
        data.categoryId = categoryId;
      }
      return api.post('/content/upload', data);
    }
  },

  // 5. 兼容旧版内容API
  legacyContent: {
    // 通用内容获取
    get: (path) => api.get(`/content/${path}`),
    
    // 分类内容获取
    getByCategory: (category, path) => api.get(`/${category}/${path}`)
  },

  // === 层级数据管理 ===
  
  // 层级数据API
  hierarchy: {
    // 获取完整的层级数据
    getData: () => api.get('/hierarchy'),
    
    // 获取可用分类列表（管理端）
    getAvailableCategories: () => api.get('/admin/hierarchy/categories'),
    
    // 获取可用项目列表（管理端）
    getAvailableItems: () => api.get('/admin/hierarchy/items'),
    
    // 管理端层级数据管理
    getHierarchyData: () => api.get('/admin/hierarchy'),
    
    // 分类页面关系管理
    addCategoryToPage: (pageId, categoryId) => {
      return api.post(`/admin/hierarchy/pages/${pageId}/categories/${categoryId}`)
    },
    
    removeCategoryFromPage: (pageId, categoryId) => {
      return api.delete(`/admin/hierarchy/pages/${pageId}/categories/${categoryId}`)
    },
    
    // 项目分类关系管理
    addItemToCategory: (categoryId, itemId) => {
      return api.post(`/admin/hierarchy/categories/${categoryId}/items/${itemId}`)
    },
    
    removeItemFromCategory: (categoryId, itemId) => {
      return api.delete(`/admin/hierarchy/categories/${categoryId}/items/${itemId}`)
    },
    
    // 页面项目关系管理
    managePageItemRelation: (pageId, itemId, action) => {
      return api.post('/admin/page-item-relation', {
        pageId,
        itemId,
        action
      })
    },
    
    // 项目关联关系管理
    addItemToPageItem: (pageItemId, relatedItemId) => {
      return api.post('/admin/item-relations', {
        pageItemId,
        relatedItemId
      })
    },
    
    removeItemFromPageItem: (pageItemId, relatedItemId) => {
      return api.delete('/admin/item-relations', {
        data: {
          pageItemId,
          relatedItemId
        }
      })
    },
    
    // 获取页面项目关联关系
    getPageItemRelations: (pageItemId) => {
      return api.get(`/items/${pageItemId}/related`)
    }
  },

  // === 用户认证 ===
  
  // 用户登录
  /**
   * 用户登录方法
   * @param {string} username - 用户名
   * @param {string} password - 密码
   * @returns {Promise<Object>} 返回用户信息对象
   */
  async login(username, password) {
    try {
      const response = await api.post('/auth/login', { username, password });
      
      // 响应拦截器返回的是处理后的数据对象 {code, data, message}
      // 检查响应是否成功且包含用户数据
      if (response && response.code === 200 && response.data && response.data.token) {
        // 设置认证token
        this.setAuthToken(response.data.token);
        return response.data;
      } else {
        throw new Error('登录失败：响应数据格式错误');
      }
    } catch (error) {
      console.error('登录错误详情:', error);
      if (error.response && error.response.data) {
        throw new Error(error.response.data.message || '登录失败');
      }
      throw new Error(error.message || '登录失败');
    }
  },
  
  // 获取当前用户信息
  async getUserInfo() {
    try {
      const response = await api.get('/admin/auth/user-info');
      return response.data.data;
    } catch (error) {
      console.error('获取用户信息失败:', error);
      return null;
    }
  },
  
  // 退出登录
  logout() {
    // 清除本地存储的token和用户信息
    localStorage.removeItem('token');
    localStorage.removeItem('userInfo');
    // 清除请求头中的token
    this.setAuthToken(null);
  },

  // === 辅助方法 ===
  
  // 获取所有分类（兼容旧版）
  getCategories() {
    return [
      'about',
      'colleges',
      'freshman',
      'life',
      'study',
      'calendar'
    ];
  },

  // 获取API基础URL
  getBaseURL() {
    return api.defaults.baseURL;
  },

  // 设置认证token（如果需要）
  setAuthToken(token) {
    if (token) {
      api.defaults.headers.common['Authorization'] = `Bearer ${token}`;
    } else {
      delete api.defaults.headers.common['Authorization'];
    }
  },

  // 通用错误处理
  handleError(error) {
    console.error('API Error:', error);
    if (error.response) {
      // 服务器响应错误
      const { status, data } = error.response;
      return {
        status,
        message: data.msg || data.message || '服务器错误',
        data: data
      };
    } else if (error.request) {
      // 网络错误
      return {
        status: 0,
        message: '网络连接错误',
        data: null
      };
    } else {
      // 其他错误
      return {
        status: -1,
        message: error.message || '未知错误',
        data: null
      };
    }
  }
};

export default apiService;